home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Lib / tai / tai_chan.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  11.1 KB  |  526 lines
  1. /* tai_chan.c: channel specific tailoring code */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Lib/tai/RCS/tai_chan.c,v 6.0 1991/12/18 20:24:59 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Lib/tai/RCS/tai_chan.c,v 6.0 1991/12/18 20:24:59 jpo Rel $
  9.  *
  10.  * $Log: tai_chan.c,v $
  11.  * Revision 6.0  1991/12/18  20:24:59  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16.  
  17.  
  18. #include    "head.h"
  19. #include    <isode/cmd_srch.h>
  20. #include    "chan.h"
  21. #include    "adr.h"
  22.  
  23.  
  24.  
  25. extern void err_abrt ();
  26. extern void tai_error ();
  27. extern    CMD_TABLE        qtbl_con_type[],
  28.                 atbl_types[],
  29.                 atbl_subtypes[];
  30. static char chn_str[] =        "chan";
  31. static int ch_numchans = 0;
  32. static int ch_maxchans = 0;
  33.  
  34. /* tables */
  35. #define CH_NAME            1
  36. #define CH_PROGNAME        2
  37. #define CH_SHOW            3
  38. #define CH_CHAN_TYPE        4
  39. #define CH_CONTENT_IN        5
  40. #define CH_DRCHAN        6
  41. #define CH_CONTENT_OUT        7
  42. #define CH_COST            8
  43. #define CH_SORT            9
  44. #define CH_IN_INFO        10
  45. #define CH_AD_TYPE        11
  46. #define CH_AD_SUBTYPE        12
  47. #define CH_AD_ORDER        13
  48. #define CH_BPT_IN        14
  49. #define CH_BPT_OUT        15
  50. #define CH_HDR_IN        16
  51. #define CH_HDR_OUT        17
  52. #define CH_TABLE        18
  53. #define CH_XMTA            19
  54. #define CH_ACCESS        20
  55. #define CH_PROBE        21
  56. #define CH_AUTHTBL        22
  57. #define CH_DOMPARSE        23
  58. #define CH_CONV            24
  59. #define CH_MAXPROC        25
  60. #define CH_KEY            26
  61. #define CH_OUT_INFO        27
  62. #define CH_OUT_AD_TYPE        28
  63. #define CH_IN_AD_TYPE        29
  64. #define CH_IN_SUBTYPE        30
  65. #define CH_OUT_SUBTYPE        31
  66. #define CH_MTA_TABLE        32
  67. #define CH_TRACE_TYPE        33
  68. #define CH_IN_TABLE        34
  69. #define CH_SOLO_PROC        35
  70. #define CH_BADSENDER_POLICY    36
  71. #define CH_CHECK_MODE        37
  72.  
  73. static CMD_TABLE   chtbl_key[] = {
  74.     "access",        CH_ACCESS,
  75.     "adr",            CH_AD_TYPE,
  76.     "adr-order",        CH_AD_ORDER,
  77.     "auth-tbl",        CH_AUTHTBL,
  78.     "bad-sender-policy",    CH_BADSENDER_POLICY,
  79.     "bptin",        CH_BPT_IN,
  80.     "bptout",        CH_BPT_OUT,
  81.     "check",        CH_CHECK_MODE,
  82.     "content-in",        CH_CONTENT_IN,
  83.     "content-out",        CH_CONTENT_OUT,
  84.     "conv",            CH_CONV,
  85.     "cost",            CH_COST,
  86.     "domain-norm",        CH_DOMPARSE,
  87.     "drchan",        CH_DRCHAN,
  88.     "hdrin",        CH_HDR_IN,
  89.     "hdrout",        CH_HDR_OUT,
  90.     "in-info",        CH_IN_INFO,
  91.     "ininfo",        CH_IN_INFO,
  92.     "inadr",        CH_IN_AD_TYPE,
  93.     "insubadr",        CH_IN_SUBTYPE,
  94.     "intable",        CH_IN_TABLE,
  95.     "key",            CH_KEY,
  96.     "maxproc",        CH_MAXPROC,
  97.     "mta",            CH_XMTA,
  98.     "mtatable",        CH_MTA_TABLE,
  99.     "name",            CH_NAME,
  100.     "out-info",        CH_OUT_INFO,
  101.     "outinfo",        CH_OUT_INFO,
  102.     "outadr",        CH_OUT_AD_TYPE,
  103.     "outsubadr",        CH_OUT_SUBTYPE,
  104.     "outtable",        CH_TABLE,
  105.     "probe",        CH_PROBE,
  106.     "prog",            CH_PROGNAME,
  107.     "show",            CH_SHOW,
  108.     "solo-proc",        CH_SOLO_PROC,
  109.     "sort",            CH_SORT,
  110.     "subadr",        CH_AD_SUBTYPE,
  111.     "trace",        CH_TRACE_TYPE,
  112.     "type",            CH_CHAN_TYPE,
  113.     0,            -1
  114.     };
  115. #define N_CHANTBLENT    ((sizeof(chtbl_key)/sizeof(CMD_TABLE)) - 1)
  116.  
  117.  
  118.  
  119. static CMD_TABLE   chtbl_types[] = {
  120.     "both",            CH_BOTH,
  121.     "debris",        CH_DEBRIS,
  122.     "delete",        CH_DELETE,
  123.     "in",            CH_IN,
  124.     "out",            CH_OUT,
  125.     "qmgrload",        CH_QMGR_LOAD,
  126.     "shaper",        CH_SHAPER,
  127.     "split",        CH_SPLITTER,
  128.     "timeout",        CH_TIMEOUT,
  129.     "warn",            CH_WARNING,
  130.     0,            -1
  131.     };
  132. #define N_CHANTYPES    ((sizeof(chtbl_types)/sizeof(CMD_TABLE)) - 1)
  133.  
  134.  
  135. static CMD_TABLE   chtbl_sort[] = {
  136.     "mta",            CH_SORT_MTA,
  137.     "priority",        CH_SORT_PRIORITY,
  138.     "size",            CH_SORT_SIZE,
  139.     "time",            CH_SORT_TIME,
  140.     "user",            CH_SORT_USR,
  141.     "none",            CH_SORT_NONE,
  142.     0,            -1
  143.     };
  144. #define N_CHANSORT    ((sizeof(chtbl_sort)/sizeof(CMD_TABLE)) - 1)
  145.  
  146. static CMD_TABLE   chtbl_ad_order[] = {
  147.     "usa",            CH_USA_ONLY,
  148.     "uk",            CH_UK_ONLY,
  149.     "usapref",        CH_USA_PREF,
  150.     "ukpref",        CH_UK_PREF,
  151.     0,            -1
  152.     };
  153.  
  154. static CMD_TABLE chtbl_access[] = {
  155.     "mta",        CH_MTA,
  156.     "mts",        CH_MTS,
  157.     0,            -1
  158.     };
  159.  
  160. static CMD_TABLE chtbl_domparse[] = {
  161.     "full",        CH_DOMAIN_NORM_ALL,
  162.     "partial",    CH_DOMAIN_NORM_PARTIAL,
  163.     0,        -1
  164.     };
  165.  
  166. static CMD_TABLE chtbl_conv[] = {
  167.     "none",        CH_CONV_NONE,
  168.     "1148",        CH_CONV_1148,
  169.     "conv",        CH_CONV_CONVERT,
  170.     "loss",        CH_CONV_WITHLOSS,
  171.     0,        -1
  172.     };
  173.  
  174. static CMD_TABLE chtbl_trace[] = {
  175.     "via",        CH_TRACE_VIA,
  176.     "received",    CH_TRACE_RECEIVED,
  177.     "x400",        CH_TRACE_X400,
  178.     0,        -1
  179.     };
  180.  
  181. static CMD_TABLE chtbl_badsender_policy[] = {
  182.     "strict",    CH_BADSENDER_STRICT,
  183.     "sloppy",    CH_BADSENDER_SLOPPY,
  184.     0, -1
  185.     };
  186.  
  187. static CMD_TABLE chtbl_check[] = {
  188.     "strict",     CH_STRICT_CHECK,
  189.     "sloppy",    CH_SLOPPY_CHECK,
  190.     NULLCP,    NOTOK
  191.     };
  192.  
  193. /* ---------------------  Begin     Routines  -------------------------------- */
  194.  
  195. chan_tai (argc, argv)
  196. int    argc;
  197. char    **argv;
  198. {
  199.     register CHAN    *cp;
  200.     char        *arg,
  201.             *p,
  202.             *ch_sort_arg[CH_MAX_SORT];
  203.     int        ind,
  204.             val,
  205.             i, j,
  206.             n_ch_sort;
  207.  
  208.  
  209.     PP_DBG (("chan_tai()"));
  210.  
  211.     if (argc < 2 || lexequ (argv[0], chn_str) != 0)     return (NOTOK);
  212.  
  213.     arg = *++argv;
  214.  
  215.     if (ch_maxchans == 0) {
  216.         ch_maxchans = 10;
  217.         ch_all = (CHAN **)smalloc (sizeof(CHAN *) * ch_maxchans);
  218.     }
  219.     else if (ch_numchans + 1 == ch_maxchans) {
  220.         ch_maxchans += 10;
  221.         ch_all = (CHAN **)realloc ((char *)ch_all,
  222.                        (unsigned) sizeof (CHAN *) * ch_maxchans);
  223.         if (ch_all == NULL)
  224.             err_abrt (RP_MECH, "Out of space for channels");
  225.     }
  226.     ch_all[ch_numchans++] = cp = (CHAN *) smalloc ((sizeof (CHAN)));
  227.     ch_all[ch_numchans] = NULLCHAN;
  228.  
  229.  
  230.     /* -- Initialize the malloc'd channel -- */
  231.     bzero ((char *)cp, sizeof(*cp));
  232. /*    cp -> ch_sort[1]    = CH_SORT_TIME; */
  233.     cp -> ch_name        = arg;
  234.     cp -> ch_access        = CH_MTA;
  235.     cp -> ch_ad_order    = CH_USA_ONLY;
  236.     cp -> ch_in_ad_type    = AD_822_TYPE;
  237.     cp -> ch_out_ad_type    = AD_822_TYPE;
  238.     cp -> ch_domain_norm    = CH_DOMAIN_NORM_PARTIAL;
  239.     cp -> ch_conversion    = CH_CONV_NONE;
  240.     cp -> ch_badSenderPolicy = CH_BADSENDER_STRICT;
  241.  
  242.     argc -= 2;
  243.     argv++;
  244.  
  245.     for (ind = 0; ind < argc; ind++) {
  246.  
  247.         if ((p = index (argv[ind], '=')) == NULLCP)
  248.             continue;
  249.  
  250.         *p++ = '\0';
  251.         PP_DBG (("tai/tai_chan %s = %s", argv[ind], p));
  252.  
  253.         switch (cmdbsrch (argv[ind], chtbl_key, N_CHANTBLENT)) {
  254.  
  255.             case CH_NAME:
  256.             cp->ch_name = p;
  257.             break;
  258.  
  259.             case CH_PROGNAME:
  260.             cp->ch_progname = p;
  261.             break;
  262.  
  263.             case CH_SHOW:
  264.             cp->ch_show = p;
  265.             break;
  266.  
  267.             case CH_KEY:
  268.             if (txt2listbpt (&cp -> ch_key, p) == NOTOK)
  269.                 tai_error ("bad keys %s for %s",
  270.                        p, cp -> ch_name);
  271.             break;
  272.  
  273.             case CH_CHAN_TYPE:
  274.             val = cmdbsrch (p, chtbl_types, N_CHANTYPES);
  275.             if (val == NOTOK)
  276.                 tai_error ("Unknown type %s in chan %s",
  277.                        p, cp->ch_name);
  278.             else
  279.                 cp -> ch_chan_type = val;
  280.             break;
  281.  
  282.             case CH_DRCHAN:
  283.             cp->ch_drchan = p;
  284.             break;
  285.  
  286.             case CH_COST:
  287.             cp->ch_cost = atoi(p);
  288.             break;
  289.  
  290.             case CH_SORT:
  291.             n_ch_sort = sstr2arg
  292.                 (p, CH_MAX_SORT, ch_sort_arg, " ");
  293.  
  294.             if (n_ch_sort < 0 || n_ch_sort > CH_MAX_SORT) {
  295.                 tai_error ("Too many sort keys for %s",
  296.                        cp -> ch_name);
  297.                 n_ch_sort = CH_MAX_SORT;
  298.             }
  299.  
  300.             for (i=j=0; i < n_ch_sort; i++) {
  301.                 val = cmdbsrch (ch_sort_arg[i],
  302.                         chtbl_sort, N_CHANSORT);
  303.                 if (val == NOTOK)
  304.                     tai_error ("%s bad sort key for %s",
  305.                            ch_sort_arg[i],
  306.                            cp -> ch_name);
  307.                 else cp->ch_sort[j++] = val;
  308.             }
  309.             break;
  310.  
  311.             case CH_IN_INFO:
  312.             cp->ch_in_info = p;
  313.             break;
  314.  
  315.             case CH_OUT_INFO:
  316.             cp->ch_out_info = p;
  317.             break;
  318.  
  319.             case CH_CONTENT_IN:
  320.             cp->ch_content_in = p;
  321.             break;
  322.  
  323.             case CH_CONTENT_OUT:
  324.             cp->ch_content_out = p;
  325.             break;
  326.  
  327.             case CH_AD_TYPE:
  328.             val = cmd_srch (p, atbl_types);
  329.             if (val == NOTOK)
  330.                 tai_error ("Unknown adr type %s in chan %s",
  331.                        p, cp->ch_name);
  332.             cp -> ch_in_ad_type =
  333.                 cp -> ch_out_ad_type = val;
  334.             break;
  335.  
  336.             case CH_IN_AD_TYPE:
  337.             val = cmd_srch (p, atbl_types);
  338.             if (val == NOTOK)
  339.                 tai_error ("Unknown inadr type %s in chan %s",
  340.                        p, cp->ch_name);
  341.             else
  342.                 cp -> ch_in_ad_type = val;
  343.             break;
  344.  
  345.             case CH_OUT_AD_TYPE:
  346.             val = cmd_srch (p, atbl_types);
  347.             if (val == NOTOK)
  348.                 tai_error ("Unknown adr out type %s in chan %s",
  349.                        p, cp->ch_name);
  350.  
  351.             else
  352.                 cp -> ch_out_ad_type = val;
  353.             break;
  354.  
  355.             case CH_AD_SUBTYPE:
  356.             val = cmd_srch (p, atbl_subtypes);
  357.             if (val == NOTOK)
  358.                 tai_error ("Unknown ad subtype %s in chan %s",
  359.                        p, cp->ch_name);
  360.  
  361.             else
  362.                 cp -> ch_in_ad_subtype =
  363.                     cp -> ch_out_ad_subtype = val;
  364.             break;
  365.  
  366.             case CH_IN_SUBTYPE:
  367.             val = cmd_srch (p, atbl_subtypes);
  368.             if (val == NOTOK)
  369.                 tai_error ("Unknown adr insubtype %s in chan %s",
  370.                        p, cp->ch_name);
  371.             else
  372.                 cp -> ch_in_ad_subtype = val;
  373.             break;
  374.  
  375.             case CH_OUT_SUBTYPE:
  376.             val = cmd_srch (p, atbl_subtypes);
  377.             if (val == NOTOK)
  378.                 tai_error ("Unknown adr outsubtype %s in chan %s",
  379.                        p, cp->ch_name);
  380.             else
  381.                 cp -> ch_out_ad_subtype = val;
  382.             break;
  383.  
  384.             case CH_AD_ORDER:
  385.             val = cmd_srch (p, chtbl_ad_order);
  386.             if (val == NOTOK)
  387.                 tai_error ("Unknown adr-order %s in chan %s",
  388.                        p, cp->ch_name);
  389.  
  390.             else
  391.                 cp -> ch_ad_order = val;
  392.             break;
  393.  
  394.  
  395.             case CH_BPT_IN:
  396.             if (txt2listbpt (&cp -> ch_bpt_in, p) == NOTOK)
  397.                 tai_error ("Bad body part in for %s",
  398.                        cp -> ch_name);
  399.             break;
  400.  
  401.             case CH_BPT_OUT:
  402.             if (txt2listbpt (&cp -> ch_bpt_out, p) == NOTOK)
  403.                 tai_error ("Bad body part out for %s",
  404.                        cp -> ch_name);
  405.             break;
  406.  
  407.             case CH_HDR_IN:
  408.             if (txthdr2listbpt (&cp -> ch_hdr_in, p) == NOTOK)
  409.                 tai_error ("Bad hdr part in for %s",
  410.                        cp -> ch_name);
  411.             break;
  412.  
  413.             case CH_HDR_OUT:
  414.             if (txthdr2listbpt (&cp -> ch_hdr_out, p) == NOTOK)
  415.                 tai_error ("Bad hdr part out for %s",
  416.                        cp -> ch_name);
  417.             break;
  418.  
  419.             case CH_TABLE:
  420.             if ((cp -> ch_table = tb_nm2struct (p)) == NULLTBL)
  421.                 tai_error ("Unknown table %s for %s",
  422.                        p, cp -> ch_name);
  423.             break;
  424.  
  425.             case CH_MTA_TABLE:
  426.             if ((cp -> ch_mta_table = tb_nm2struct (p)) == NULLTBL)
  427.                 tai_error ("Unknown table %s for %s",
  428.                        p, cp -> ch_name);
  429.             break;
  430.             case CH_IN_TABLE:
  431.             if ((cp -> ch_in_table = tb_nm2struct (p)) == NULLTBL)
  432.                 tai_error ("Unknown table %s for %s",
  433.                        p, cp -> ch_name);
  434.             break;
  435.  
  436.             case CH_AUTHTBL:
  437.             if ((cp -> ch_auth_tbl = tb_nm2struct (p)) == NULLTBL)
  438.                 tai_error ("Unknown table %s for %s",
  439.                        p, cp -> ch_name);
  440.             break;
  441.  
  442.             case CH_XMTA:
  443.             cp -> ch_mta = p;
  444.             break;
  445.  
  446.             case CH_ACCESS:
  447.             val = cmd_srch (p, chtbl_access);
  448.             if (val != NOTOK)
  449.                 cp -> ch_access = val;
  450.             else
  451.                 tai_error ("Unknown access type %s in chan %s",
  452.                        p, cp->ch_name);
  453.  
  454.             break;
  455.  
  456.             case CH_PROBE:
  457.             if (*p == 'y')
  458.                 cp -> ch_probe = TRUE;
  459.             break;
  460.  
  461.             case CH_DOMPARSE:
  462.             val = cmd_srch (p, chtbl_domparse);
  463.             if (val != NOTOK)
  464.                 cp -> ch_domain_norm = val;
  465.             else
  466.                 tai_error ("Unknown domparse %s in chan %s",
  467.                        p, cp->ch_name);
  468.  
  469.             break;
  470.  
  471.             case CH_MAXPROC:
  472.             cp -> ch_maxproc = atoi (p);
  473.             break;
  474.             case CH_CONV:
  475.             val = cmd_srch (p, chtbl_conv);
  476.             if (val != NOTOK)
  477.                 cp -> ch_conversion = val;
  478.             else
  479.                 tai_error ("Unknown conv type %s in chan %s",
  480.                        p, cp->ch_name);
  481.  
  482.             break;
  483.             case CH_TRACE_TYPE:
  484.             val = cmd_srch (p, chtbl_trace);
  485.  
  486.             if (val != NOTOK)
  487.                 cp -> ch_trace_type = val;
  488.             else
  489.                 tai_error ("Unknown trace type %s in chan %s",
  490.                        p, cp->ch_name);
  491.  
  492.             break;
  493.  
  494.             case CH_SOLO_PROC:
  495.             if (*p == 'y')
  496.                 cp -> ch_solo_proc = TRUE;
  497.             break;
  498.             
  499.             case CH_BADSENDER_POLICY:
  500.             val = cmd_srch (p, chtbl_badsender_policy);
  501.  
  502.             if (val != NOTOK)
  503.                 cp -> ch_badSenderPolicy = val;
  504.             else
  505.                 tai_error ("Unknown bad sender policy '%s' for chan %s",
  506.                        p, cp->ch_name);
  507.             break;
  508.  
  509.             case CH_CHECK_MODE:
  510.             val = cmd_srch (p, chtbl_check);
  511.             if (val != NOTOK)
  512.                 cp -> ch_strict_mode = val;
  513.             else val = CH_STRICT_CHECK;
  514.             break;
  515.  
  516.             default:
  517.             tai_error("Unknown key '%s' for %s",
  518.                   argv[ind], cp -> ch_name);
  519.         }
  520.  
  521.     }
  522.  
  523.  
  524.     return (OK);
  525. }
  526.